///////////////////////////////////////////////////////////////////////////////
//
// lighthouse3D - 3D Software Library
//
// File: CBasicClasses.h
//
///////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2003-2013 Marcus Reinhardt
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
//
///////////////////////////////////////////////////////////////////////////////
//
// You can find a copy of the GNU General Public License (gpl.txt) in the
// directory of the library.
//
///////////////////////////////////////////////////////////////////////////////

#ifndef _CBasicClasses_H_
#define _CBasicClasses_H_

#include <stdio.h>
#include <stdlib.h>
#include <vector>
#include "CBasicDefs.h"

///////////////////////////////////////////////////////////////////////////////
// struct TMeshVertex : Storage for a 3D vertex with texture coordinates
///////////////////////////////////////////////////////////////////////////////

//! Storage for a 3D vertex with texture coordinates

struct TMeshVertex
{
public:

    TMeshVertex() : x(0.0f), y(0.0f), z(0.0f), xt(0.0f), yt(0.0f), zt(0.0f), xtc(0.0f), ytc(0.0f), ztc(0.0f), sx(0), sy(0), u(0.0f), v(0.0f), vnx(0.0f), vny(0.0f), vnz(0.0f) {}

    // Original data
    float x;
    float y;
    float z;

    // Transformed (skaled, rotated or translated) data
    float xt;
    float yt;
    float zt;

    // Transformed (skaled, rotated or translated) camera data 
    float xtc;
    float ytc;
    float ztc;

	// Projected data
    int sx;
    int sy;

    // Texture data
    float u;
    float v;
    
    // Vertex Normal
    float vnx;
    float vny;
    float vnz;

    // Transformed Vertex Normal
    float vnxt;
    float vnyt;
    float vnzt;

    // Transformed Vertex Normal Camera adjusted
    float vnxtc;
    float vnytc;
    float vnztc;
};

///////////////////////////////////////////////////////////////////////////////
// struct TMeshTriangle : Storage for a 3D triangle, indices to a vertex list
///////////////////////////////////////////////////////////////////////////////

//! Storage for a 3D triangle, indices to a vertex list

struct TMeshTriangle
{
    TMeshTriangle() {  v[0] = v[1] = v[2] = 0; texture = -1;
                       ut[0] = ut[1] = ut[2] = 0;
                       vt[0] = vt[1] = vt[2] = 0;
                       nv[0] = nv[1] = nv[2] = 0;             
                       nvt[0] = nvt[1] = nvt[2] = 0;             }

    float        ut[3];
    float        vt[3];
    float        nv[3];
    float        nvt[3];
    float        nvtc[3];
    int 		 v[3];
    int          texture;
    float        distance;
    bool         bfCulled;
    bool         zClipped;
};

///////////////////////////////////////////////////////////////////////////////
// struct TMeshTexture : Storage for a 3D texture image
///////////////////////////////////////////////////////////////////////////////

//! Storage for a 3D texture image

struct TMeshTexture
{
    TMeshTexture()
    {
        m_width  = 0;
        m_height = 0;

        strcpy(m_name, "");
    }

   ~TMeshTexture()
    {
        release();
    }

    void release()
    {
        m_width  = 0;
        m_height = 0;

        strcpy(m_name, "");
    }

    char           m_name[512];
    unsigned int   m_width;
    unsigned int   m_height;    
    unsigned int   m_image[_maxTexSizeX_*_maxTexSizeY_];
};

///////////////////////////////////////////////////////////////////////////////
// struct T3DPosition : Contains the position description of a mesh
///////////////////////////////////////////////////////////////////////////////

//! Contains the position description of a mesh

struct T3DPosition
{
    T3DPosition() {  xr = yr = zr = 0;
                     xs = ys = zs = 0;
                     xt = yt = zt = 0; }

    ///////////////////////////////////////////////////////////////////////////////
    // for rotation
    ///////////////////////////////////////////////////////////////////////////////
    int xr, yr, zr;
    ///////////////////////////////////////////////////////////////////////////////
    // for skalation
    ///////////////////////////////////////////////////////////////////////////////
    float xs, ys, zs;
    float xs_rel, ys_rel, zs_rel;
    ///////////////////////////////////////////////////////////////////////////////
    // for translation
    ///////////////////////////////////////////////////////////////////////////////
    float xt, yt, zt;
    float xt_rel, yt_rel, zt_rel;

	bool rot_changed, skal_changed, trans_changed;

};

///////////////////////////////////////////////////////////////////////////////
// struct T2DData : Screen data
///////////////////////////////////////////////////////////////////////////////

//! Screen data

struct T2DData
{
  unsigned int d[_maxScreenSizeX_*_maxScreenSizeY_];
};

///////////////////////////////////////////////////////////////////////////////
// struct TZData
///////////////////////////////////////////////////////////////////////////////

//! ZBuffer data

struct TZData
{
  float d[_maxScreenSizeX_*_maxScreenSizeY_];
};

///////////////////////////////////////////////////////////////////////////////
// struct TLineData : required to transfer line data
///////////////////////////////////////////////////////////////////////////////

//! Line transfer data

struct TLineData
{
  float Lx3D, Ly3D, Lz3D;
  float Rx3D, Ry3D, Rz3D;
  float LuT3D, LvT3D, LzT3D;
  float RuT3D, RvT3D, RzT3D;
  float intLambert;
  float intLambertPhLR, intLambertPhLG, intLambertPhLB;
  float Lint, Rint;
  float LintR, LintG, LintB;
  float RintR, RintG, RintB;
  float LnvX, LnvY, LnvZ;
  float RnvX, RnvY, RnvZ;
  float dvTex;
  int   Lx, Rx, y;

  TMeshTexture *tex;
};

///////////////////////////////////////////////////////////////////////////////
// struct TRGBTriple
///////////////////////////////////////////////////////////////////////////////

//! RGB data

struct TRGBColorTriple
{
  int r,g,b;
};

///////////////////////////////////////////////////////////////////////////////
// struct TLibrarySetup
///////////////////////////////////////////////////////////////////////////////

//! Library setup data

struct TLibrarySetup
{

  ///////////////////////////////////////////////////////////////////////////////
  // 0: None
  // 1: WireFrame
  // 2: Texture
  ///////////////////////////////////////////////////////////////////////////////
  int texRenderer;
  
  int wireFrameColor;

  ///////////////////////////////////////////////////////////////////////////////
  // 0: None
  // 1: Lambert
  // 2: Gouraud
  // 4: Phong
  ///////////////////////////////////////////////////////////////////////////////
  int texShader;

  ///////////////////////////////////////////////////////////////////////////////
  // 0: None
  // 1: Backface Culling
  ///////////////////////////////////////////////////////////////////////////////
  int bfCulling;

  ///////////////////////////////////////////////////////////////////////////////
  // 0: None (not defined!)
  // 1: Lambert
  // 2: Phong
  ///////////////////////////////////////////////////////////////////////////////
  int texLighting;

  ///////////////////////////////////////////////////////////////////////////////
  // 0: None
  // 1: Linear
  // 2: Bilinear
  // 4: Trilinear
  ///////////////////////////////////////////////////////////////////////////////
  int texFilter;

  ///////////////////////////////////////////////////////////////////////////////
  // 0: None
  // 1: Bilinear
  ///////////////////////////////////////////////////////////////////////////////
  int fsAA;
  
  ///////////////////////////////////////////////////////////////////////////////
  // 1: Internal 2D Screen
  // 2: External DirectDraw Surface
  ///////////////////////////////////////////////////////////////////////////////
  int usedScreen;
  
  ///////////////////////////////////////////////////////////////////////////////
  // 0: none
  // 1: linear
  // 2: exponential
  ///////////////////////////////////////////////////////////////////////////////
  int fogSynthesis;

  ///////////////////////////////////////////////////////////////////////////////
  // 0: no logo
  // 1: Engine tries to show Logo if it could be loaded
  ///////////////////////////////////////////////////////////////////////////////
  int showLogo;

  int colDetect;
  ///////////////////////////////////////////////////////////////////////////////
  // 0: disable collision detection
  // 1: enable collision detection
  ///////////////////////////////////////////////////////////////////////////////
};

///////////////////////////////////////////////////////////////////////////////
// struct TLibraryInfo
///////////////////////////////////////////////////////////////////////////////

//! Library informations as c-strings

struct TLibraryInfo
{
  char engineAbilities[16384];
  char engineDeveloper[255];
  char engineName[255];
  char engineVersion[255];
};

///////////////////////////////////////////////////////////////////////////////
// struct TOrderedTrList
///////////////////////////////////////////////////////////////////////////////

//! The triangles of the scene in a z-sorted order

struct TOrderedTrList
{
  int           mesh;
  TMeshTriangle *t;
};

///////////////////////////////////////////////////////////////////////////////
// struct TPictureData
///////////////////////////////////////////////////////////////////////////////

//! Transfer class for picture data

struct TPictureData
{
  int          sizeX, sizeY;
  unsigned char raw[_maxPicSizeX_*_maxPicSizeY_*3];
  unsigned int rgb[_maxPicSizeX_*_maxPicSizeY_];
};

///////////////////////////////////////////////////////////////////////////////
// struct TFontLetter
///////////////////////////////////////////////////////////////////////////////

struct TFontLetter
{
  int          sizeX, sizeY;
  unsigned int rgb[_maxFontSize_*_maxFontSize_];
};

///////////////////////////////////////////////////////////////////////////////
// struct TFontData
///////////////////////////////////////////////////////////////////////////////

struct TFontStructureData
{
  int fontOffset;
  int sizeY;
  unsigned int transparentColor;
  unsigned int startColor;
  unsigned int endColor;
  TFontLetter fontData[512];
};

///////////////////////////////////////////////////////////////////////////////
// struct TGUIHandle
///////////////////////////////////////////////////////////////////////////////

struct TGUIHandle
{
    char caption[128];
    int x,y,w,h,h2;
    int type;
    int fontColor;
    int handle;
	bool visible;
    TGUIHandle *parent;
};

#endif
